m4_dnl vim: ft=bib expandtab shiftwidth=4

@inproceedings{sabbah:aosd04,
    title           = {Aspects: from promise to reality},
    author          = {Daniel Sabbah},
    pages           = {1-2},
    crossref        = {:aosd04},
_start_extra
    doi             = {http://doi.acm.org/10.1145/976270.976271},
    abstract        = {The concepts underpinning Aspect Oriented Software Development (AOSD) have been with us for many years. The last couple of years have been particularly exciting, with much of the promise brought into sharp reality. The timing for our industry couldn't be more critical; urgent help is needed to address the growing software complexity crisis. Deployment of uniform implementations of cross-cutting concerns into a range of software products is now feasible, and large and complex software can be factored and recomposed into simpler, better targeted, higher quality offerings. In this talk we describe how IBM plans to put this technology into production to simplify the delivery and service of high quality software, to deliver new solutions for our customers' development requirements, to create opportunities for customers to add value to their software, and to accelerate new initiatives at the heart of IBM's software strategy.}
_stop
}

@inproceedings{nuseibeh:aosd04,
    title           = {Crosscutting requirements},
    author          = {Bashar Nuseibeh},
    pages           = {3-4},
    crossref        = {:aosd04},
_start_extra
    doi             = {http://doi.acm.org/10.1145/976270.976272},
    abstract        = {Evidence is mounting that aspect-oriented programming is useful for (re-)structuring the many concerns that software is designed to address. Many of these concerns often arise in the problem domain, and, therefore, there is a growing effort to examine 'early aspects' - to identify and represent concerns that arise during software requirements engineering and design, and to determine how these concerns interact. But can one seek to identify aspects too early? While identifying concerns during requirements elicitation may indeed be profitable, the notion of crosscutting concerns, indeed of crosscutting requirements, may only make sense when elements of a solution also begin to be explored. There are two consequences of this: a case for more interleaving of the processes of requirements engineering and design, and a case for the explicit development of specifications that map the problem and solution structures. We elaborate and discuss this thesis, and offer an alternative research agenda for aspect-oriented requirements engineering.},
_stop
}

@inproceedings{boner:aosd04,
    title           = {What are the key issues for commercial {AOP} use: how does {AspectWerkz} address them?},
    author          = {Jonas Bonér},
    pages           = {5-6},
    crossref        = {:aosd04},
_start_extra
    doi             = {http://doi.acm.org/10.1145/976270.976273},
    abstract        = {AspectWerkz is a framework targeted towards dynamic aspect-oriented programming (AOP) in commercial applications. Based on our experience designing and supporting AspectWerkz, we have identified what we believe are key issues for the commercial adoption of AOP. These are usability, agility, integration, expressiveness, performance, tool support and the concept of an aspect container that manages issues like security, isolation, visibility, deployment and manageability for the aspects. This invited talk will discuss these issues and how AspectWerkz tries to address them.},
_stop
}

@inproceedings{nishizawa:aosd04,
    title           = {Remote pointcut: a language construct for distributed {AOP}},
    author          = {Muga Nishizawa and Shigeru Chiba and Michiaki Tatsubori},
    pages           = {7-15},
    crossref        = {:aosd04},
_start_extra
    doi             = {http://doi.acm.org/10.1145/976270.976274},
    abstract        = {This paper presents our extension to AspectJ for distributed computing. Although AspectJ allows Java developers to modularize a crosscutting concern as an aspect, this paper shows that some crosscutting concerns in distributed computing are not modularized in AspectJ as simple aspects. Rather, aspects modularizing such a concern tend to be in code spread over multiple hosts and explicitly communicated across the network. This paper illustrates this fact with an example of testing a distributed program written in AspectJ with Java RMI. To address this complexity caused by network communication, this paper proposes an extension to AspectJ for distributed computing. The language construct that we call remote pointcut enables developers to write a simple aspect to modularize crosscutting concerns distributed on multiple hosts. This paper presents DJcutter, which is our AspectJ-like language supporting remote pointcuts.},
_stop
}

@inproceedings{sakurai:aosd04,
    title           = {Association aspects},
    author          = {Kouhei Sakurai and Hidehiko Masuhara and Naoyasu Ubayashi and Saeko Matsuura and Seiichi Komiya},
    pages           = {16-25},
    crossref        = {:aosd04},
_start_extra
    doi             = {http://doi.acm.org/10.1145/976270.976275},
    abstract        = {We propose a linguistic mechanism for AspectJ-like languages that concisely associates aspect instances to object groups. The mechanism, which supports association aspects, extends the per-object aspects in AspectJ by allowing an aspect instance to be associated to a group of objects, and by providing a new pointcut primitive to specify aspect instances as execution contexts of advice. With association aspects, we can straightforwardly implement crosscutting concerns that have stateful behavior related to a particular group of objects. The new pointcut primitive can more flexibly specify aspect instances when compared against previous implicit mechanisms. The comparison of execution times between the programs with association aspects and the ones with regular AspectJ aspects revealed that the association aspects exhibited almost equivalent for the medium-sized configurations.},
_stop
}

@inproceedings{hilsdale:aosd04,
    title           = {Advice weaving in {AspectJ}},
    author          = {Erik Hilsdale and Jim Hugunin},
    pages           = {26-35},
    crossref        = {:aosd04},
_start_extra
    doi             = {http://doi.acm.org/10.1145/976270.976276},
    abstract        = {This paper describes the implementation of advice weaving in AspectJ. The AspectJ language picks out dynamic join points in a program's execution with pointcuts and uses advice to change the behavior at those join points. The core task of AspectJ's advice weaver is to statically transform a program so that at runtime it will behave according to the AspeetJ language semantics. This paper describes the 1.1 implementation which is based on transforming bytecode. We describe how AspectJ's join points are mapped to regions of bytecode, how these regions are efficiently matched by AspectJ's pointcuts, and how pieces of advice are efficiently implemented at these regions. We also discuss both run-time and compile-time performance of this implementation.},
_stop
}

@inproceedings{gray:aosd04,
    title           = {A technique for constructing aspect weavers using a program transformation engine},
    author          = {Jeff Gray and Suman Roychoudhury},
    pages           = {36-45},
    crossref        = {:aosd04},
_start_extra
    doi             = {http://doi.acm.org/10.1145/976270.976277},
    abstract        = {As aspect-orientation grows in influence, the scope of applicability also will need to expand. The new approaches for improved modularization offered by aspect-orientation can provide benefits not only to new development efforts, but to legacy systems as well. A difficulty with legacy system adoption of aspect-orientation, however, is in the construction of new weavers for the disparate programming languages in which the legacy software is coded. In this paper, we describe our experience with using a program transformation system as the underlying engine for weaver construction. In particular, the capability for weaving aspects into Object Pascal (Delphi) is demonstrated using the Design Maintenance System (DMS). From this Object Pascal weaving environment, the improved modularization of several crosscutting concerns in a commercial software application is shown. The paper also describes an initial approach for construction of language-independent aspect weavers.},
_stop
}

@inproceedings{hanenberg:aosd04,
    title           = {Morphing aspects: incompletely woven aspects and continuous weaving},
    author          = {Stefan Hanenberg and Robert Hirschfeld and Rainer Unland},
    pages           = {46-55},
    crossref        = {:aosd04},
_start_extra
    doi             = {http://doi.acm.org/10.1145/976270.976278},
    abstract        = {Weaving is one of the fundamental mechanisms of aspect-oriented systems. A weaver composes different aspects with the base system by determining and adapting all parts where aspect specific elements are needed eventually. At runtime, timeconsuming join point checks are necessary to determine if at a certain join point aspect-specific code needs to be executed. Current technologies enforce such checks even in locations that only temporarily or under restrictive conditions (or even never) execute aspect-specific code. In more complex applications, a large number of these checks fail and just cause a substantial runtime overhead without contributing to the system's overall behavior. The main reason for this flaw is complete weaving, the way how aspects are woven to an application using current technologies. In this paper we discuss the problem of unnecessary join point checks caused by complete weaving. We introduce morphing aspects - incompletely woven aspects in combination with continuous weaving - to overcome the problem of futile join point checks.},
_stop
}

@inproceedings{colyer:aosd04,
    title           = {Large-scale {AOSD} for middleware},
    author          = {Adrian Colyer and Andrew Clement},
    pages           = {56-65},
    crossref        = {:aosd04},
_start_extra
    doi             = {http://doi.acm.org/10.1145/976270.976279},
    abstract        = {For a variety of reasons, today's middleware systems are highly complex. This complexity surfaces internally in the middleware construction, and externally in the programming models supported and features offered. We believed that aspect-orientation could help with these problems, and undertook a case study based on members of an IBM middleware product-line. We also wanted to know whether aspect-oriented techniques could scale to commercial project sizes with tens of thousands of classes, many millions of lines of code, hundreds of developers, and sophisticated build systems. This paper describes the motivation for our research, the challenges involved, and key lessons that we learnt in refactoring both homogeneous and heterogeneous crosscutting concerns in the middleware.},
_stop
}

@inproceedings{duzan:aosd04,
    title           = {Building adaptive distributed applications with middleware and aspects},
    author          = {Gary Duzan and Joseph Loyall and Richard Schantz and Richard Shapiro and John Zinky},
    pages           = {66-73},
    crossref        = {:aosd04},
_start_extra
    doi             = {http://doi.acm.org/10.1145/976270.976280},
    abstract        = {Middleware technologies allow the development of distributed applications without explicit knowledge of the networking involved. However, in the face of changing network and CPU conditions across the distributed system, these applications often will need to adapt their behavior to maintain an acceptable quality of service (QoS), which implies a knowledge of these conditions. This adaptation is neither part of the application logic nor part of the distribution middleware, and so represents a separate concern which needs to be addressed.This paper describes an aspect-based approach to programming QoS adaptive applications that separates the QoS and adaptation concerns from the functional and distribution concerns. To simplify aspect development for these applications, our approach integrates a domain-specific adaptation specification with a novel aspect language which includes distribution and adaptation-specific join points in its join point model. We compare and contrast this with existing aspect-oriented language approaches and illustrate our approach with an example distributed system application.},
_stop
}

@inproceedings{gobel:aosd04,
    title           = {The {COMQUAD} component model: enabling dynamic selection of implementations by weaving non-functional aspects},
    author          = {Steffen Göbel and Christoph Pohl and Simone Röttger and Steffen Zschaler},
    pages           = {74-82},
    crossref        = {:aosd04},
_start_extra
    doi             = {http://doi.acm.org/10.1145/976270.976281},
    abstract        = {The reliability of non-functional contracts is crucial for many software applications. This added to the increasing attention this issue lately received in software engineering. Another development in software engineering is toward component-based systems. The interaction of both, non-functional aspects and components, is a relatively new research area, which the COMQUAD project is focusing on.Our component model, presented in this paper, enables the specification and runtime support of non-functional aspects in component-based systems. At the same time, a clear separation of non-functional properties and functionally motivated issues is provided. We achieve this by extending the concepts of the existing component-based systems Enterprise JavaBeans (EJB) and CORBA Components (CCM). Non-functional aspects are described orthogonally to the application structure using descriptors, and are woven into the running application by the component container acting as a contract manager. The container implicitly instantiates component specifications and connects them according to the current requests. The selection of actual implementations depends on the particular client's non-functional requirements. This technique also enables adaptation based on the specific quantitative capabilities of the running system.In this paper we give a detailed description of the COMQUAD component model and the appropriate container support. We also provide a simple case study of a multimedia application for better understanding.},
_stop
}

@inproceedings{bockisch:aosd04,
    title           = {Virtual machine support for dynamic join points},
    author          = {Christoph Bockisch and Michael Haupt and Mira Mezini and Klaus Ostermann},
    pages           = {83-92},
    crossref        = {:aosd04},
_start_extra
    doi             = {http://doi.acm.org/10.1145/976270.976282},
    abstract        = {A widespread implementation approach for the join point mechanism of aspect-oriented languages is to instrument areas in code that match the static part of pointcut designators, inserting dynamic checks for that part of matching that depends on run-time conditions, if needed. For performance reasons, such dynamic checks should be avoided whenever possible. One way to do so is to postpone weaving of advice calls until run-time, when conditions determining the emergence of join points hold. This calls for fluid code---code that adapts itself to the join point emergence at run-time, and suggests that AOP concepts should be integrated into the execution model underlying a VM. In this paper, we present first steps toward such an integration in Steamloom, an extension of IBM's Jikes Research Virtual Machine. Steamloom is fairly restricted, but our initial experimental results indicate that aspect-aware VMs and fluid code are promising w.r.t performance. While the focus in this paper is on performance, there are other advantages of aspect-aware VMs to be investigated in the future.},
_stop
}

@inproceedings{ettinger:aosd04,
    title           = {Untangling: a slice extraction refactoring},
    author          = {Ran Ettinger and Mathieu Verbaere},
    pages           = {93-101},
    crossref        = {:aosd04},
_start_extra
    doi             = {http://doi.acm.org/10.1145/976270.976283},
    abstract        = {Separation of concerns in existing code can be achieved by specific refactoring techniques. Modern refactoring tools support a number of well-known refactoring transformations, including method extraction. In this paper, we examine how method extraction can be improved through program slicing. Furthermore, we show how a generalization of such slice extraction can be applied to untangle existing code by extracting aspects.},
_stop
}

@inproceedings{chiba:aosd04,
    title           = {Josh: an open {AspectJ}-like language},
    author          = {Shigeru Chiba and Kiyoshi Nakagawa},
    pages           = {102-111},
    crossref        = {:aosd04},
_start_extra
    doi             = {http://doi.acm.org/10.1145/976270.976284},
    abstract        = {Although aspect-oriented programming (AOP) is becoming widely used, the design of the pointcut language and the generic and reusable description of advice are still research topics. To address these topics, this paper presents Josh, which is our new AspectJ-like language with an extensible pointcut language and a few mechanisms for generic description. The extensible pointcut language is based on the idea of open compiler. Since Josh allows defining a new pointcut designator in Java, the users can define a pointcut designator useful in a particular application domain. Also, Josh allows any Java expression to be included in the body of advice. This mechanism enables the generic and reusable description of advice.},
_stop
}

@inproceedings{haley:aosd04,
    title           = {Deriving security requirements from crosscutting threat descriptions},
    author          = {Charles B. Haley and Robin C. Laney and Bashar Nuseibeh},
    pages           = {112-121},
    crossref        = {:aosd04},
_start_extra
    doi             = {http://doi.acm.org/10.1145/976270.976285},
    abstract        = {It is generally accepted that early determination of the stakeholder requirements assists in the development of systems that better meet the needs of those stakeholders. General security requirements frustrate this goal because it is difficult to determine how they affect the functional requirements of the system.This paper illustrates how representing threats as crosscutting concerns aids in determining the effect of security requirements on the functional requirements. Assets (objects that have value in a system) are first enumerated, and then threats on these assets are listed. The points where assets and functional requirements join are examined to expose vulnerabilities to the threats. Security requirements, represented as constraints, are added to the functional requirements to reduce the scope of the vulnerabilities. These requirements are used during the analysis and specification process, thereby incorporating security concerns into the functional requirements of the system.},
_stop
}

@inproceedings{harbulot:aosd04,
    title           = {Using {AspectJ} to separate concerns in parallel scientific {Java} code},
    author          = {Bruno Harbulot and John R. Gurd},
    pages           = {122-131},
    crossref        = {:aosd04},
_start_extra
    doi             = {http://doi.acm.org/10.1145/976270.976286},
    abstract        = {Scientific software frequently demands high performance in order to execute complex models in acceptable time. A major means of obtaining high performance is via parallel execution on multi-processor systems. However, traditional methods of programming for parallel execution can lead to substantial code-tangling where the needs of the mathematical model crosscut with the concern of parallel execution.Aspect-Oriented Programming is an attractive technology for solving the problem of code-tangling in high performance parallel scientific software. The underlying mathematical model and the parallelism can be treated as separate concerns and programmed accordingly. Their elements of code can then be woven together to produce the final application. This paper investigates the extent to which AspectJ technology can be used to achieve the desired separation of concerns in programs from the Java Grande Forum benchmark suite, a set of test applications for evaluation of the performance of Java in the context of numerical computation. The paper analyses three different benchmark programs and classifies the degrees of difficulty in separating concerns within them in a form suitable for AspectJ. This leads to an assessment of the influence of the design of a numerical application on the ability of AspectJ to solve this kind of code-tangling problem. It is concluded that: (1) scientific software is rarely produced in true object-oriented style; and (2) the inherent loop structure of many scientific algorithms is incompatible with the join point philosophy of AspectJ.Since AspectJ cannot intercept the iterations of for-loops (which are at the heart of high-performance computing), various object-oriented models are proposed for describing (embarrassingly parallel) rectangular double-nested forloops that make it possible to use AspectJ for encapsulating parallelisation in an aspect. Finally, a test-case using these models is presented, together with performance results obtained on various Java Virtual Machines.},
_stop
}

@inproceedings{dhondt:aosd04,
    title           = {Hybrid aspects for weaving object-oriented functionality and rule-based knowledge},
    author          = {Maja D'Hondt and Viviane Jonckers},
    pages           = {132-140},
    crossref        = {:aosd04},
_start_extra
    doi             = {http://doi.acm.org/10.1145/976270.976287},
    abstract        = {Software applications often consist of implicit knowledge for making decisions or giving advice in addition to object-oriented functionality. A rule-based system can be employed for representing and reasoning with this knowledge. Although several hybrid systems exist that combine object-oriented programming and rule-based reasoning, a survey we conducted reveals that both paradigms are not well integrated and programs are tightly coupled.We propose hybrid aspects for integrating object-oriented programming and rule-based reasoning. As expected, hybrid aspects specify join points where normal execution is interrupted and advice is executed. However, since two different languages are involved, we need join point models for both and advice that activates both. As such, we complement a simple join point model for object-oriented programming with a join point model for rule-based reasoning. Hybrid advice is independent of the interrupted language and supports sending messages as well as activating rules. It uses values of either language transparently.We present OReA, an implementation of hybrid aspects for weaving Smalltalk and a rule-based system. We discuss and illustrate two applications of hybrid aspects.},
_stop
}

@inproceedings{douence:aosd04,
    title           = {Composition, reuse and interaction analysis of stateful aspects},
    author          = {Rémi Douence and Pascal Fradet and Mario Südholt},
    pages           = {141-150},
    crossref        = {:aosd04},
_start_extra
    doi             = {http://doi.acm.org/10.1145/976270.976288},
    abstract        = {Aspect-Oriented Programming promises separation of concerns at the implementation level. However, aspects are not always orrthogonal and aspect interaction is a fundamental problem. In this paper, we extend previous work on a generic framework for the formal definition and interaction analysis of stateful aspects. We propose three important extensions which enhance expressivity while preserving static analyzability of interactions. First, we provide support for variables in aspects in order to share information between different execution points. This allows the definition of more precise aspects and to avoid detection of spurious conflicts. Second, we introduce generic composition operators for aspects. This enables us to provide expressive support for the resolution of conflicts among interacting aspects. Finally, we offer a means to define applicability conditions for aspects. This makes interaction analysis more precise and paves the way for reuse of aspects by making explicit requirements on contexts in which aspects must be used.},
_stop
}

@proceedings{:aosd04,
    title           = {_proc(3rd _int _conf,_aosd,{AOSD}-2004)},
    booktitle       = {_proc(3rd _int _conf,_aosd,{AOSD}-2004)},
    editor          = {Karl Lieberherr},
    publisher       = {_acm},
    year            = 2004,
    month           = mar,
_start_extra
    location        = {Lancaster, England},
    abstract        = {AOSD '04, held at Lancaster UK, March 22-26, 2004, is the third annual conference on Aspect-oriented Software Development. This volume comprises the proceedings of AOSD '04. Over the past year, interest in AOSD has continued to grow amongst both academics and practitioners. The conference program reflects this balance between leading edge research and industrial application with a mix of technical papers, reports from industry, a student research event, an industrial panel on the topic of aspect-oriented programming in the enterprise, and demonstrations from both researchers and practitioners. The six workshops and seven tutorials held before the start of the main conference reflected the breadth of topics of interest to the AOSD community from general aspect programming language issues and software development practices to specific domains such as aspects for application-level security. The 15 papers presented as part of the technical program were selected from 82 submissions (up 17 per cent from 2003). The program committee met on Dec. 12 and 13, 2003 at Northeastern University to select the papers. All papers were reviewed by at least three reviewers, except program committee papers that were read by at least 4 reviewers. As part of the technical program, we are also honoured to present two invited keynote speakers: Daniel Sabbah, an IBM Vice President, who will describe how IBM plans to put aspect-oriented technology into production, and Bashar Nuseibeh, a Professor at The Open University who has done pioneering work on viewpoints in requirements engineering and who will offer a research agenda for aspect-oriented requirements engineering. In addition, we are also thrilled to present an invited state-of-the-art speaker, Jonas Bonér, who will describe his novel AspectWerkz technology.}
_stop
}

@inproceedings{zook:gpce04,
    crossref        = {:gpce04},
    title           = {Generating {AspectJ} programs with {Meta-AspectJ}},
    author          = {David Zook and Shan Shan Huang and Yannis Smaragdakis},
    pages           = {1-18},
_start_extra
    url             = {http://springerlink.metapress.com/openurl.asp?genre=article&issn=0302-9743&volume=3286&spage=1},
_stop
}

@inproceedings{mcdirmid:gpce04,
    crossref        = {:gpce04},
    title           = {{Splice}: {Aspects} that analyze programs},
    author          = {Sean McDirmid and Wilson C. Hsieh},
    pages           = {19-38},
_start_extra
    url             = {http://springerlink.metapress.com/openurl.asp?genre=article&issn=0302-9743&volume=3286&spage=19},
_stop
}

@inproceedings{smith:gpce04,
    crossref        = {:gpce04},
    title           = {A generative approach to aspect-oriented programming},
    author          = {Douglas R. Smith},
    pages           = {39-54},
_start_extra
    url             = {http://springerlink.metapress.com/openurl.asp?genre=article&issn=0302-9743&volume=3286&spage=39},
_stop
}


@inproceedings{lohmann:gpce04,
    crossref        = {:gpce04},
    title           = {Generic Advice: {On} the combination of {AOP} with generative programming in {AspectC++}},
    author          = {Daniel Lohmann and Georg Blaschke and Olaf Spinczyk},
    pages           = {55-74},
_start_extra
    url             = {http://springerlink.metapress.com/openurl.asp?genre=article&issn=0302-9743&volume=3286&spage=55},
_stop
}

@inproceedings{rashid:gpce04,
    crossref        = {:gpce04},
    title           = {Supporting flexible object database evolution with aspects},
    author          = {Awais Rashid and Nicholas Leidenfrost},
    pages           = {75-94},
_start_extra
    url             = {http://springerlink.metapress.com/openurl.asp?genre=article&issn=0302-9743&volume=3286&spage=75},
_stop
}

@inproceedings{douence:gpce04,
    crossref        = {:gpce04},
    title           = {A crosscut language for control-flow},
    author          = {Rémi Douence and Luc Teboul},
    pages           = {95-114},
_start_extra
    url             = {http://springerlink.metapress.com/openurl.asp?genre=article&issn=0302-9743&volume=3286&spage=95},
_stop
}

@inproceedings{jackson:gpce04,
    crossref        = {:gpce04},
    title           = {Source-level cross-language aspect-oriented programming},
    author          = {Andrew Jackson and Siobhán Clarke},
    pages           = {115-135},
_start_extra
    url             = {http://springerlink.metapress.com/openurl.asp?genre=article&issn=0302-9743&volume=3286&spage=115},
_stop
}

@proceedings{:gpce04,
    month           = oct,
    year            = 2004,
    editor          = {Gabor Karsai and Eelco Visser},
    title           = {_proc(3rd _int _conf,_gpce,{GPCE}-2004)},
    booktitle       = {_proc(3rd _int _conf,_gpce,{GPCE}-2004)},
    publisher       = {_sv},
    address         = {Berlin},
    series          = {_lncs},
    volume          = 3286,
_start_extra
    location        = {Vancouver},
    isbn            = {3-540-23580-9},
_stop
}

@article{wand:toplas04,
    author          = {Mitchel Wand and Gregor Kiczales and Christopher Dutchyn},
    title           = {A semantics for advice and dynamic join points in aspect-oriented programming},
    journal         = {_trans(_plas,TOPLAS)},
    volume          = 26,
    number          = 5,
    pages           = {890-910},
    month           = sep,
    year            = 2004
}

@inproceedings{mezini:fse04,
    title           = {Variability Management with Aspects},
    author          = {Mira Mezini and Klaus Ostermann},
    crossref        = {:fse04},
    pages           = {127-136},
}

@inproceedings{krishnamurthi:fse04,
    title           = {Verifying Aspect Advice Modularly},
    author          = {Shriram Krishnamurthi and Kathi Fisler and Michael Greenberg},
    crossref        = {:fse04},
    pages           = {137-146},
}

@inproceedings{rinard:fse04,
    title           = {A Classification System and Analysis for Aspect-Oriented Programs},
    author          = {Martin Rinard and Alexandru Sălcianu and Suhabe Bugrara},
    crossref        = {:fse04},
    pages           = {147-158},
}

@inproceedings{walker:fse04,
    title           = {Implementing Protocols via Declarative Event Patterns},
    pages           = {159-169},
    author          = {Robert Walker and Kevin Viggers},
    crossref        = {:fse04},
}

@proceedings{:fse04,
    title           = {_proc(12th ACM SIGSOFT _int _symp,Foundations of _se,{FSE}-2004)},
    booktitle       = {_proc(12th ACM SIGSOFT _int _symp,Foundations of _se,{FSE}-2004)},
    editor          = {Richard N. Taylor and Matthew B. Dwyer},
    publisher       = {_acm},
    year            = 2004,
    month           = nov,
_start_extra
    location        = {Newport Beach, California},
_stop
}

@book{miles:ajcook04,
    title           = {{AspectJ} Cookbook},
    author          = {Russell Miles},
    publisher       = {O'Reilly},
    month           = dec,
    year            = 2004
}

@inproceedings{verheecke:ecows04,
    title           = {Aspect-Oriented Programming for Dynamic Web Service Monitoring and Selection},
    author          = {Bart Verheecke and María Agustina Cibrán},
    pages           = {15-29},
    crossref        = {:ecows04}
}

@inproceedings{charfi:ecows04,
    title           = {Aspect-Oriented Web Service Composition},
    author          = {Anis Charfi and Mira Mezini},
    pages           = {168-182},
    crossref        = {:ecows04}
}

@proceedings{:ecows04,
    month           = sep,
    year            = 2004,
    editor          = {Liang-Jie Zhang and Mario Jeckle},
    title           = {_proc(_eur _conf,Web Services,{ECOWS}-2004)},
    booktitle       = {_proc(_eur _conf,Web Services,{ECOWS}-2004)},
    publisher       = {_sv},
    address         = {Berlin},
    series          = {_lncs},
    volume          = 3250,
_start_extra
    location        = {Erfurt, Germany},
    isbn            = {3540232028},
_stop
}

@inproceedings{baniassad:icse04,
    author          = {Elisa L.A. Baniassad and Siobhán Clarke},
    title           = {{Theme}: {An} Approach for Aspect-Oriented Analysis and Design},
    booktitle       = {_proc(26th _int _conf,_se,{ICSE}-2004)},
    editor          = {Jacky Estublier and David S. Rosenblum},
    year            = 2004,
    publisher       = {_acm},
    month           = may,
    pages           = {158-167},
_start_extra
    location        = {Edinburgh, Scotland, UK},
    isbn            = {0-7695-2163-0}
_stop
}
